package 炫彩基类

import (
	"unsafe"

	common "gitee.com/go_888/xcgui/xcgui/common"

	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// 列表_创建, 创建列表元素, 返回元素句柄.
//
//
//
//
//
// ff:列表_创建
// x:元素x坐标
// y:元素y坐标
// cx:宽度
// cy:高度
// hParent:父窗口句柄
func X列表_创建(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄 int) int {
	r, _, _ := xList_Create.Call(uintptr(元素x坐标), uintptr(元素y坐标), uintptr(宽度), uintptr(高度), uintptr(父窗口句柄))
	return int(r)
}

// 列表_创建Ex, 创建列表元素, 使用内置项模板, 自动创建数据适配器, 返回元素句柄.
//
//
//
//
//
//
// ff:列表_创建Ex
// x:元素x坐标
// y:元素y坐标
// cx:宽度
// cy:高度
// hParent:父窗口句柄
// col_extend_count:列数量
func X列表_创建Ex(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄, 列数量 int32) int {
	r, _, _ := xList_CreateEx.Call(uintptr(元素x坐标), uintptr(元素y坐标), uintptr(宽度), uintptr(高度), uintptr(父窗口句柄), uintptr(列数量))
	return int(r)
}

// 列表_增加列, 返回位置索引.
//
//
// ff:列表_增加列
// hEle:元素句柄
// width:列宽度
func X列表_增加列(元素句柄 int, 列宽度 int32) int32 {
	r, _, _ := xList_AddColumn.Call(uintptr(元素句柄), uintptr(列宽度))
	return int32(r)
}

// 列表_插入列, 返回插入位置索引.
//
//
//
// ff:列表_插入列
// hEle:元素句柄
// width:列宽度
// iItem:项索引
func X列表_插入列(元素句柄 int, 列宽度 int32, 项索引 int32) int32 {
	r, _, _ := xList_InsertColumn.Call(uintptr(元素句柄), uintptr(列宽度), uintptr(项索引))
	return int32(r)
}

// 列表_启用多选, 启用或关闭多选功能.
//
//
// ff:列表_启用多选
// hEle:元素句柄
// bEnable:是否启用
func X列表_启用多选(元素句柄 int, 是否启用 bool) {
	xList_EnableMultiSel.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用拖动更改列宽, 启用拖动改变列宽度.
//
//
// ff:列表_启用拖动更改列宽
// hEle:元素句柄
// bEnable:是否启用
func X列表_启用拖动更改列宽(元素句柄 int, 是否启用 bool) {
	xList_EnableDragChangeColumnWidth.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用垂直滚动条顶部对齐.
//
//
// ff:列表_启用垂直滚动条顶部对齐
// hEle:元素句柄
// bTop:是否启用
func X列表_启用垂直滚动条顶部对齐(元素句柄 int, 是否启用 bool) {
	xList_EnableVScrollBarTop.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用行背景铺满.
//
//
// ff:列表_启用行背景铺满
// hEle:元素句柄
// bFull:是否启用
func X列表_启用行背景铺满(元素句柄 int, 是否启用 bool) {
	xList_EnableRowBkFull.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用固定行高.
//
//
// ff:列表_启用固定行高
// hEle:元素句柄
// bEnable:是否启用
func X列表_启用固定行高(元素句柄 int, 是否启用 bool) {
	xList_EnableFixedRowHeight.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用模板复用.
//
//
// ff:列表_启用模板复用
// hEle:元素句柄
// bEnable:是否启用
func X列表_启用模板复用(元素句柄 int, 是否启用 bool) {
	xList_EnableTemplateReuse.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_启用虚表.
//
//
// ff:列表_启用虚表
// hEle:元素句柄
// bEnable:是否启用
func X列表_启用虚表(元素句柄 int, 是否启用 bool) {
	xList_EnableVirtualTable.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否启用))
}

// 列表_置虚表行数.
//
//
// ff:列表_设置虚表行数
// hEle:元素句柄
// nRowCount:行数
func X列表_设置虚表行数(元素句柄 int, 行数 int32) {
	xList_SetVirtualRowCount.Call(uintptr(元素句柄), uintptr(行数))
}

// 列表_置排序, 设置排序属性.
//
//
//
//
// ff:列表_设置排序
// hEle:元素句柄
// iColumn:列索引
// iColumnAdapter:适配器中列索引
// bEnable:启用排序
func X列表_设置排序(元素句柄 int, 列索引 int32, 适配器中列索引 int32, 启用排序 bool) {
	xList_SetSort.Call(uintptr(元素句柄), uintptr(列索引), uintptr(适配器中列索引), common.X布尔值到uintptr(启用排序))
}

// 列表_置行背景绘制标志. 设置是否绘制指定状态下行的背景.
//
//
// ff:列表_设置行背景绘制标志
// hEle:
// nFlags:标志位
func X列表_设置行背景绘制标志(hEle int, 标志位 xcc.X项背景绘制标识) {
	xList_SetDrawRowBkFlags.Call(uintptr(hEle), uintptr(标志位))
}

// 列表_置列宽.
//
//
//
// ff:列表_设置列宽
// hEle:元素句柄
// iItem:项索引
// width:宽度
func X列表_设置列宽(元素句柄 int, 项索引, 宽度 int32) {
	xList_SetColumnWidth.Call(uintptr(元素句柄), uintptr(项索引), uintptr(宽度))
}

// 列表_置列最小宽度.
//
//
//
// ff:列表_设置列最小宽度
// hEle:元素句柄
// iItem:项索引
// width:宽度
func X列表_设置列最小宽度(元素句柄 int, 项索引, 宽度 int32) {
	xList_SetColumnMinWidth.Call(uintptr(元素句柄), uintptr(项索引), uintptr(宽度))
}

// 列表_置列宽度固定.
//
//
//
// ff:列表_设置列宽度固定
// hEle:元素句柄
// iColumn:列索引
// bFixed:固定宽度
func X列表_设置列宽度固定(元素句柄 int, 列索引 int32, 固定宽度 bool) {
	xList_SetColumnWidthFixed.Call(uintptr(元素句柄), uintptr(列索引), common.X布尔值到uintptr(固定宽度))
}

// 列表_取列宽度.
//
//
// ff:列表_取列宽度
// hEle:元素句柄
// iColumn:列索引
func X列表_取列宽度(元素句柄 int, 列索引 int32) int32 {
	r, _, _ := xList_GetColumnWidth.Call(uintptr(元素句柄), uintptr(列索引))
	return int32(r)
}

// 列表_取列数量.
//
// ff:列表_取列数量
// hEle:元素句柄
func X列表_取列数量(元素句柄 int) int32 {
	r, _, _ := xList_GetColumnCount.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_置项数据, 设置项用户数据.
//
//
//
//
// ff:列表_设置项数据
// hEle:元素句柄
// iItem:项索引
// iSubItem:子项索引
// data:用户数据
func X列表_设置项数据(元素句柄 int, 项索引 int32, 子项索引 int32, 用户数据 int) bool {
	r, _, _ := xList_SetItemData.Call(uintptr(元素句柄), uintptr(项索引), uintptr(子项索引), uintptr(用户数据))
	return r != 0
}

// 列表_取项数据, 获取项用户数据.
//
//
//
// ff:列表_取项数据
// hEle:元素句柄
// iItem:项索引
// iSubItem:子项索引
func X列表_取项数据(元素句柄 int, 项索引, 子项索引 int32) int {
	r, _, _ := xList_GetItemData.Call(uintptr(元素句柄), uintptr(项索引), uintptr(子项索引))
	return int(r)
}

// 列表_置选择行.
//
//
// ff:列表_设置选择行
// hEle:元素句柄
// iRow:行索引
func X列表_设置选择行(元素句柄 int, 行索引 int32) bool {
	r, _, _ := xList_SetSelectRow.Call(uintptr(元素句柄), uintptr(行索引))
	return r != 0
}

// 列表_取选择行, 返回行索引.
//
// ff:列表_取选择行
// hEle:元素句柄
func X列表_取选择行(元素句柄 int) int32 {
	r, _, _ := xList_GetSelectRow.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_取选择行数量, 获取选择行数量.
//
// ff:列表_取选择行数量
// hEle:元素句柄
func X列表_取选择行数量(元素句柄 int) int32 {
	r, _, _ := xList_GetSelectItemRow.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_添加选择行.
//
//
// ff:列表_添加选择行
// hEle:元素句柄
// iRow:行索引
func X列表_添加选择行(元素句柄 int, 行索引 int32) bool {
	r, _, _ := xList_AddSelectRow.Call(uintptr(元素句柄), uintptr(行索引))
	return r != 0
}

// 列表_置选择全部, 选择全部行.
//
// ff:列表_设置选择全部
// hEle:元素句柄
func X列表_设置选择全部(元素句柄 int) {
	xList_SetSelectAll.Call(uintptr(元素句柄))
}

// 列表_取全部选择, 获取全部选择的行, 返回行数量.
//
//
//
// ff:列表_取全部选择
// hEle:元素句柄
// pArray:返回行索引
// nArraySize:数组大小
func X列表_取全部选择(元素句柄 int, 返回行索引 *[]int32, 数组大小 int32) int32 {
	if 数组大小 < 1 {
		return 0
	}
	*返回行索引 = make([]int32, 数组大小)
	r, _, _ := xList_GetSelectAll.Call(uintptr(元素句柄), uintptr(unsafe.Pointer(&(*返回行索引)[0])), uintptr(数组大小))
	return int32(r)
}

// 列表_显示指定行, 滚动视图让指定行可见.
//
//
// ff:显示指定行
// hEle:元素句柄
// iRow:行索引
func X显示指定行(元素句柄 int, 行索引 int32) {
	xList_VisibleRow.Call(uintptr(元素句柄), uintptr(行索引))
}

// 列表_取消选择行, 取消选择指定行.
//
//
// ff:列表_取消选择行
// hEle:元素句柄
// iRow:行索引
func X列表_取消选择行(元素句柄 int, 行索引 int32) bool {
	r, _, _ := xList_CancelSelectRow.Call(uintptr(元素句柄), uintptr(行索引))
	return r != 0
}

// 列表_取消全部选择项, 取消选择所有项(这里的项可以理解为行).
//
// ff:列表_取消全部选择项
// hEle:元素句柄
func X列表_取消全部选择项(元素句柄 int) {
	xList_CancelSelectAll.Call(uintptr(元素句柄))
}

// 列表_取列表头, 获取列表头元素, 返回列表头元素句柄.
//
// ff:列表_取列表头
// hEle:元素句柄
func X列表_取列表头(元素句柄 int) int {
	r, _, _ := xList_GetHeaderHELE.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_删除列.
//
//
// ff:列表_删除列
// hEle:元素句柄
// iItem:项索引
func X列表_删除列(元素句柄 int, 项索引 int32) bool {
	r, _, _ := xList_DeleteColumn.Call(uintptr(元素句柄), uintptr(项索引))
	return r != 0
}

// 列表_删除全部列, 删除所有的列, 仅删除List的, 数据适配器的列不变.
//
// ff:列表_删除全部列
// hEle:元素句柄
func X列表_删除全部列(元素句柄 int) {
	xList_DeleteColumnAll.Call(uintptr(元素句柄))
}

// 列表_绑定数据适配器.
//
//
// ff:列表_绑定数据适配器
// hEle:元素句柄
// hAdapter:数据适配器句柄
func X列表_绑定数据适配器(元素句柄 int, 数据适配器句柄 int) {
	xList_BindAdapter.Call(uintptr(元素句柄), uintptr(数据适配器句柄))
}

// 列表_列表头绑定数据适配器.
//
//
// ff:列表_列表头绑定数据适配器
// hEle:元素句柄
// hAdapter:数据适配器句柄
func X列表_列表头绑定数据适配器(元素句柄 int, 数据适配器句柄 int) {
	xList_BindAdapterHeader.Call(uintptr(元素句柄), uintptr(数据适配器句柄))
}

// 列表_创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
//
//
// ff:列表_创建数据适配器
// hEle:元素句柄
// colExtend_count:预计列表总列数
func X列表_创建数据适配器(元素句柄 int, 预计列表总列数 int32) int {
	r, _, _ := xList_CreateAdapter.Call(uintptr(元素句柄), uintptr(预计列表总列数))
	return int(r)
}

// 列表_列表头创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
//
// ff:列表_列表头创建数据适配器
// hEle:元素句柄
func X列表_列表头创建数据适配器(元素句柄 int) int {
	r, _, _ := xList_CreateAdapterHeader.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_取数据适配器, 返回数据适配器句柄.
//
// ff:列表_取数据适配器
// hEle:元素句柄
func X列表_取数据适配器(元素句柄 int) int {
	r, _, _ := xList_GetAdapter.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_列表头获取数据适配器, 获取列表头数据适配器句柄.
//
// ff:列表_列表头获取数据适配器
// hEle:元素句柄
func X列表_列表头获取数据适配器(元素句柄 int) int {
	r, _, _ := xList_GetAdapterHeader.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_置项模板文件, 设置项布局模板文件.
//
//
// ff:列表_设置项模板文件
// hEle:元素句柄
// pXmlFile:文件名
func X列表_设置项模板文件(元素句柄 int, 文件名 string) bool {
	r, _, _ := xList_SetItemTemplateXML.Call(uintptr(元素句柄), common.X文本到uintptr(文件名))
	return r != 0
}

// 列表_置项模板从字符串, 设置项布局模板文件.
//
//
// ff:列表_设置项模板从文本
// hEle:元素句柄
// pStringXML:xml文本
func X列表_设置项模板从文本(元素句柄 int, xml文本 string) bool {
	r, _, _ := xList_SetItemTemplateXMLFromString.Call(uintptr(元素句柄), W2A(xml文本))
	return r != 0
}

// 列表_置项模板, 设置列表项模板.
//
//
// ff:列表_设置项模板
// hEle:元素句柄
// hTemp:模板句柄
func X列表_设置项模板(元素句柄 int, 模板句柄 int) bool {
	r, _, _ := xList_SetItemTemplate.Call(uintptr(元素句柄), uintptr(模板句柄))
	return r != 0
}

// 列表_取项模板对象, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
//
//
//
// ff:列表_取项模板对象
// hEle:元素句柄
// iItem:项索引
// iSubItem:子项索引
// nTempItemID:模板项ID
func X列表_取项模板对象(元素句柄 int, 项索引, 子项索引, 模板项ID int32) int {
	r, _, _ := xList_GetTemplateObject.Call(uintptr(元素句柄), uintptr(项索引), uintptr(子项索引), uintptr(模板项ID))
	return int(r)
}

// 列表_取对象所在行. 获取当前对象所在模板实例, 属于列表中哪一行. 成功返回行索引, 否则返回 xcc.XC_ID_ERROR.
//
//
// ff:列表_取对象所在行
// hEle:元素句柄
// hXCGUI:对象句柄
func X列表_取对象所在行(元素句柄 int, 对象句柄 int) int32 {
	r, _, _ := xList_GetRowIndexFromHXCGUI.Call(uintptr(元素句柄), uintptr(对象句柄))
	return int32(r)
}

// 列表_取列表头模板对象, 列表头, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
//
//
// ff:列表_取列表头模板对象
// hEle:元素句柄
// iItem:项索引
// nTempItemID:模板项ID
func X列表_取列表头模板对象(元素句柄 int, 项索引, 模板项ID int32) int {
	r, _, _ := xList_GetHeaderTemplateObject.Call(uintptr(元素句柄), uintptr(项索引), uintptr(模板项ID))
	return int(r)
}

// 列表_取列表头对象所在列. 列表头, 获取当前对象所在模板实例, 属于列表头中哪一个列. 成功返回列索引, 否则返回 xcc.XC_ID_ERROR.
//
//
// ff:列表_取列表头对象所在列
// hEle:元素句柄
// hXCGUI:对象句柄
func X列表_取列表头对象所在列(元素句柄 int, 对象句柄 int) int32 {
	r, _, _ := xList_GetHeaderColumnIndexFromHXCGUI.Call(uintptr(元素句柄), uintptr(对象句柄))
	return int32(r)
}

// 列表_置列表头高度.
//
//
// ff:列表_设置列表头高度
// hEle:元素句柄
// height:高度
func X列表_设置列表头高度(元素句柄 int, 高度 int32) {
	xList_SetHeaderHeight.Call(uintptr(元素句柄), uintptr(高度))
}

// 列表_取列表头高度.
//
// ff:列表_取列表头高度
// hEle:元素句柄
func X列表_取列表头高度(元素句柄 int) int32 {
	r, _, _ := xList_GetHeaderHeight.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_取可视行范围.
//
//
//
// ff:列表_取可视行范围
// hEle:元素句柄
// piStart:开始行索引
// piEnd:结束行索引
func X列表_取可视行范围(元素句柄 int, 开始行索引 *int32, 结束行索引 *int32) {
	xList_GetVisibleRowRange.Call(uintptr(元素句柄), uintptr(unsafe.Pointer(开始行索引)), uintptr(unsafe.Pointer(结束行索引)))
}

// 列表_置行默认高度.
//
//
//
// ff:列表_设置行默认高度
// hEle:元素句柄
// nHeight:高度
// nSelHeight:选中时高度
func X列表_设置行默认高度(元素句柄 int, 高度 int32, 选中时高度 int32) {
	xList_SetRowHeightDefault.Call(uintptr(元素句柄), uintptr(高度), uintptr(选中时高度))
}

// 列表_取行默认高度.
//
//
//
// ff:列表_取行默认高度
// hEle:元素句柄
// pHeight:返回高度
// pSelHeight:返回选中时高度
func X列表_取行默认高度(元素句柄 int, 返回高度 *int32, 返回选中时高度 *int32) {
	xList_GetRowHeightDefault.Call(uintptr(元素句柄), uintptr(unsafe.Pointer(返回高度)), uintptr(unsafe.Pointer(返回选中时高度)))
}

// 列表_置行间距.
//
//
// ff:列表_设置行间距
// hEle:元素句柄
// nSpace:行间距大小
func X列表_设置行间距(元素句柄 int, 行间距大小 int32) {
	xList_SetRowSpace.Call(uintptr(元素句柄), uintptr(行间距大小))
}

// 列表_取行间距.
//
// ff:列表_取行间距
// hEle:元素句柄
func X列表_取行间距(元素句柄 int) int32 {
	r, _, _ := xList_GetRowSpace.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_置锁定列左侧, 锁定列, 设置左侧锁定列分界列索引.
//
//
// ff:列表_设置锁定列左侧
// hEle:元素句柄
// iColumn:列索引
func X列表_设置锁定列左侧(元素句柄 int, 列索引 int32) {
	xList_SetLockColumnLeft.Call(uintptr(元素句柄), uintptr(列索引))
}

// 列表_置锁定列右侧.
//
// 暂时只支持锁定末尾列.
// ff:列表_设置锁定列右侧
// hEle:元素句柄
// iColumn:列索引
func X列表_设置锁定列右侧(元素句柄 int, 列索引 int32) {
	xList_SetLockColumnRight.Call(uintptr(元素句柄), uintptr(列索引))
}

// 列表_置锁定行底部, 设置是否锁定末尾行.
//
//
// ff:列表_设置锁定行底部
// hEle:元素句柄
// bLock:是否锁定
func X列表_设置锁定行底部(元素句柄 int, 是否锁定 bool) {
	xList_SetLockRowBottom.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否锁定))
}

// 列表_置锁定行底部重叠.
//
//
// ff:列表_设置锁定行底部重叠
// hEle:元素句柄
// bOverlap:是否重叠
func X列表_设置锁定行底部重叠(元素句柄 int, 是否重叠 bool) {
	xList_SetLockRowBottomOverlap.Call(uintptr(元素句柄), common.X布尔值到uintptr(是否重叠))
}

// 列表_测试点击项, 检测坐标点所在项.
//
//
//
//
// ff:列表_测试点击项
// hEle:元素句柄
// pPt:坐标点
// piItem:行索引
// piSubItem:列索引
func X列表_测试点击项(元素句柄 int, 坐标点 *X结构_坐标, 行索引 *int32, 列索引 *int32) bool {
	r, _, _ := xList_HitTest.Call(uintptr(元素句柄), uintptr(unsafe.Pointer(坐标点)), uintptr(unsafe.Pointer(行索引)), uintptr(unsafe.Pointer(列索引)))
	return r != 0
}

// 列表_测试点击项扩展, 检查坐标点所在项, 自动添加滚动视图偏移量.
//
//
//
//
// ff:列表_测试点击项EX
// hEle:元素句柄
// pPt:坐标点
// piItem:行索引
// piSubItem:列索引
func X列表_测试点击项EX(元素句柄 int, 坐标点 *X结构_坐标, 行索引 *int32, 列索引 *int32) bool {
	r, _, _ := xList_HitTestOffset.Call(uintptr(元素句柄), uintptr(unsafe.Pointer(坐标点)), uintptr(unsafe.Pointer(行索引)), uintptr(unsafe.Pointer(列索引)))
	return r != 0
}

// 列表_刷新项数据.
//
// ff:列表_刷新项数据
// hEle:元素句柄
func X列表_刷新项数据(元素句柄 int) {
	xList_RefreshData.Call(uintptr(元素句柄))
}

// 列表_刷新指定行. 修改数据后, 刷新指定行模板, 以便更新数据到模板(如果当前行可见).
//
//
// ff:列表_刷新指定行
// hEle:元素句柄
// iRow:行索引
func X列表_刷新指定行(元素句柄 int, 行索引 int32) {
	xList_RefreshRow.Call(uintptr(元素句柄), uintptr(行索引))
}

// 列表_添加列文本.
//
//
//
//
// ff:列表_添加列文本
// hEle:元素句柄
// nWidth:列宽
// pName:名称
// pText:文本
func X列表_添加列文本(元素句柄 int, 列宽 int32, 名称 string, 文本 string) int32 {
	r, _, _ := xList_AddColumnText.Call(uintptr(元素句柄), uintptr(列宽), common.X文本到uintptr(名称), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_添加列图片.
//
//
//
//
// ff:列表_添加列图片
// hEle:元素句柄
// nWidth:列宽
// pName:名称
// hImage:图片
func X列表_添加列图片(元素句柄 int, 列宽 int32, 名称 string, 图片 int) int32 {
	r, _, _ := xList_AddColumnImage.Call(uintptr(元素句柄), uintptr(列宽), common.X文本到uintptr(名称), uintptr(图片))
	return int32(r)
}

// 列表_添加行文本.
//
//
// ff:列表_添加行文本
// hEle:元素句柄
// pText:文本
func X列表_添加行文本(元素句柄 int, 文本 string) int32 {
	r, _, _ := xList_AddRowText.Call(uintptr(元素句柄), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_添加行文本扩展.
//
//
//
// ff:列表_添加行文本EX
// hEle:元素句柄
// pName:名称
// pText:文本
func X列表_添加行文本EX(元素句柄 int, 名称 string, 文本 string) int32 {
	r, _, _ := xList_AddRowTextEx.Call(uintptr(元素句柄), common.X文本到uintptr(名称), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_添加行图片.
//
//
// ff:列表_添加行图片
// hEle:元素句柄
// hImage:图片句柄
func X列表_添加行图片(元素句柄 int, 图片句柄 int) int32 {
	r, _, _ := xList_AddRowImage.Call(uintptr(元素句柄), uintptr(图片句柄))
	return int32(r)
}

// 列表_添加行图片扩展.
//
//
//
// ff:列表_添加行图片EX
// hEle:元素句柄
// pName:名称
// hImage:图片句柄
func X列表_添加行图片EX(元素句柄 int, 名称 string, 图片句柄 int) int32 {
	r, _, _ := xList_AddRowImageEx.Call(uintptr(元素句柄), common.X文本到uintptr(名称), uintptr(图片句柄))
	return int32(r)
}

// 列表_插入行文本.
//
//
//
// ff:列表_插入行文本
// hEle:元素句柄
// iRow:行索引
// pValue:文本
func X列表_插入行文本(元素句柄 int, 行索引 int32, 文本 string) int32 {
	r, _, _ := xList_InsertRowText.Call(uintptr(元素句柄), uintptr(行索引), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_插入行文本扩展.
//
//
//
//
// ff:插入行文本EX
// hEle:元素句柄
// iRow:行索引
// pName:名称
// pValue:文本
func X插入行文本EX(元素句柄 int, 行索引 int32, 名称 string, 文本 string) int32 {
	r, _, _ := xList_InsertRowTextEx.Call(uintptr(元素句柄), uintptr(行索引), common.X文本到uintptr(名称), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_插入行图片.
//
//
//
// ff:列表_插入行图片
// hEle:元素句柄
// iRow:行索引
// hImage:图片句柄
func X列表_插入行图片(元素句柄 int, 行索引 int32, 图片句柄 int) int32 {
	r, _, _ := xList_InsertRowImage.Call(uintptr(元素句柄), uintptr(行索引), uintptr(图片句柄))
	return int32(r)
}

// 列表_插入行图片扩展.
//
//
//
//
// ff:列表_插入行图片扩展
// hEle:元素句柄
// iRow:行索引
// pName:名称
// hImage:图片句柄
func X列表_插入行图片扩展(元素句柄 int, 行索引 int32, 名称 string, 图片句柄 int) int32 {
	r, _, _ := xList_InsertRowImageEx.Call(uintptr(元素句柄), uintptr(行索引), common.X文本到uintptr(名称), uintptr(图片句柄))
	return int32(r)
}

// 列表_置项文本.
//
//
//
//
// ff:列表_设置项文本
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// pText:文本
func X列表_设置项文本(元素句柄 int, 项索引, 列索引 int32, 文本 string) bool {
	r, _, _ := xList_SetItemText.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), common.X文本到uintptr(文本))
	return r != 0
}

// 列表_置项文本扩展.
//
//
//
//
// ff:列表_设置项文本EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// pText:文本
func X列表_设置项文本EX(元素句柄 int, 项索引 int32, 名称 string, 文本 string) bool {
	r, _, _ := xList_SetItemTextEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), common.X文本到uintptr(文本))
	return r != 0
}

// 列表_置项图片.
//
//
//
//
// ff:列表_设置项图片
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// hImage:图片
func X列表_设置项图片(元素句柄 int, 项索引, 列索引 int32, 图片 int) bool {
	r, _, _ := xList_SetItemImage.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), uintptr(图片))
	return r != 0
}

// 列表_置项图片扩展.
//
//
//
//
// ff:列表_设置项图片EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// hImage:图片
func X列表_设置项图片EX(元素句柄 int, 项索引 int32, 名称 string, 图片 int) bool {
	r, _, _ := xList_SetItemImageEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), uintptr(图片))
	return r != 0
}

// 列表_置项指数值.
//
//
//
//
// ff:列表_设置项指数值
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// nValue:值
func X列表_设置项指数值(元素句柄 int, 项索引, 列索引 int32, 值 int32) bool {
	r, _, _ := xList_SetItemInt.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), uintptr(值))
	return r != 0
}

// 列表_置项整数值扩展.
//
//
//
//
// ff:列表_设置项整数值EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// nValue:值
func X列表_设置项整数值EX(元素句柄 int, 项索引 int32, 名称 string, 值 int32) bool {
	r, _, _ := xList_SetItemIntEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), uintptr(值))
	return r != 0
}

// 列表_置项浮点值.
//
//
//
//
// ff:列表_设置项浮点值
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// fFloat:值
func X列表_设置项浮点值(元素句柄 int, 项索引, 列索引 int32, 值 float32) bool {
	r, _, _ := xList_SetItemFloat.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), common.X小数32位到uintptr(值))
	return r != 0
}

// 列表_置项浮点值扩展.
//
//
//
//
// ff:列表_设置项浮点值EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// fFloat:值
func X列表_设置项浮点值EX(元素句柄 int, 项索引 int32, 名称 string, 值 float32) bool {
	r, _, _ := xList_SetItemFloatEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), common.X小数32位到uintptr(值))
	return r != 0
}

// 列表_取项文本.
//
//
//
// ff:列表_取项文本
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
func X列表_取项文本(元素句柄 int, 项索引, 列索引 int32) string {
	r, _, _ := xList_GetItemText.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引))
	return common.Uintptr到文本(r)
}

// 列表_取项文本扩展.
//
//
//
// ff:列表_取项文本EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
func X列表_取项文本EX(元素句柄 int, 项索引 int32, 名称 string) string {
	r, _, _ := xList_GetItemTextEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称))
	return common.Uintptr到文本(r)
}

// 列表_取项图片. 返回图片句柄.
//
//
//
// ff:列表_取项图片
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
func X列表_取项图片(元素句柄 int, 项索引, 列索引 int32) int {
	r, _, _ := xList_GetItemImage.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引))
	return int(r)
}

// 列表_取项图片扩展. 返回图片句柄.
//
//
//
// ff:列表_取项图片EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
func X列表_取项图片EX(元素句柄 int, 项索引 int32, 名称 string) int {
	r, _, _ := xList_GetItemImageEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称))
	return int(r)
}

// 列表_取项整数值.
//
//
//
//
// ff:列表_取项整数值
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// pOutValue:返回值指针
func X列表_取项整数值(元素句柄 int, 项索引 int32, 列索引 int32, 返回值指针 *int32) bool {
	r, _, _ := xList_GetItemInt.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), uintptr(unsafe.Pointer(返回值指针)))
	return r != 0
}

// 列表_取项整数值扩展.
//
//
//
//
// ff:列表_取项整数值EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// pOutValue:返回值指针
func X列表_取项整数值EX(元素句柄 int, 项索引 int32, 名称 string, 返回值指针 *int32) bool {
	r, _, _ := xList_GetItemIntEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), uintptr(unsafe.Pointer(返回值指针)))
	return r != 0
}

// 列表_取项浮点值.
//
//
//
//
// ff:列表_取项浮点值
// hEle:元素句柄
// iItem:项索引
// iColumn:列索引
// pOutValue:返回值指针
func X列表_取项浮点值(元素句柄 int, 项索引, 列索引 int32, 返回值指针 *float32) bool {
	r, _, _ := xList_GetItemFloat.Call(uintptr(元素句柄), uintptr(项索引), uintptr(列索引), uintptr(unsafe.Pointer(返回值指针)))
	return r != 0
}

// 列表_取项浮点值扩展.
//
//
//
//
// ff:列表_取项浮点值EX
// hEle:元素句柄
// iItem:项索引
// pName:名称
// pOutValue:返回值指针
func X列表_取项浮点值EX(元素句柄 int, 项索引 int32, 名称 string, 返回值指针 *float32) bool {
	r, _, _ := xList_GetItemFloatEx.Call(uintptr(元素句柄), uintptr(项索引), common.X文本到uintptr(名称), uintptr(unsafe.Pointer(返回值指针)))
	return r != 0
}

// 列表_删除行.
//
//
// ff:列表_删除行
// hEle:元素句柄
// iRow:行索引
func X列表_删除行(元素句柄 int, 行索引 int32) bool {
	r, _, _ := xList_DeleteRow.Call(uintptr(元素句柄), uintptr(行索引))
	return r != 0
}

// 列表_删除行扩展.
//
//
//
// ff:列表_删除行EX
// hEle:元素句柄
// iRow:行索引
// nCount:删除数量
func X列表_删除行EX(元素句柄 int, 行索引, 删除数量 int32) bool {
	r, _, _ := xList_DeleteRowEx.Call(uintptr(元素句柄), uintptr(行索引), uintptr(删除数量))
	return r != 0
}

// 列表_删除行全部.
//
// ff:列表_删除行全部
// hEle:元素句柄
func X列表_删除行全部(元素句柄 int) {
	xList_DeleteRowAll.Call(uintptr(元素句柄))
}

// 列表_删除列全部AD.
//
// ff:列表_删除列全部AD
// hEle:元素句柄
func X列表_删除列全部AD(元素句柄 int) {
	xList_DeleteColumnAll_AD.Call(uintptr(元素句柄))
}

// 列表_取项数量AD.
//
// ff:列表_取项数量AD
// hEle:元素句柄
func X列表_取项数量AD(元素句柄 int) int32 {
	r, _, _ := xList_GetCount_AD.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_取列数量AD.
//
// ff:列表_取列数量AD
// hEle:元素句柄
func X列表_取列数量AD(元素句柄 int) int32 {
	r, _, _ := xList_GetCountColumn_AD.Call(uintptr(元素句柄))
	return int32(r)
}

// 列表_置分割线颜色.
//
//
// ff:列表_设置分割线颜色
// hEle:元素句柄
// color:ABGR颜色值
func X列表_设置分割线颜色(元素句柄 int, ABGR颜色值 int) {
	xList_SetSplitLineColor.Call(uintptr(元素句柄), uintptr(ABGR颜色值))
}

// 列表_置行高度.
//
//
//
//
// ff:列表_设置行高
// hEle:元素句柄
// iRow:行索引
// nHeight:高度
// nSelHeight:选中时高度
func X列表_设置行高(元素句柄 int, 行索引, 高度, 选中时高度 int32) {
	xList_SetRowHeight.Call(uintptr(元素句柄), uintptr(行索引), uintptr(高度), uintptr(选中时高度))
}

// 列表_取行高度.
//
//
//
//
// ff:列表_取行高度
// hEle:元素句柄
// iRow:行索引
// pHeight:返回高度
// pSelHeight:返回选中时高度
func X列表_取行高度(元素句柄 int, 行索引 int32, 返回高度, 返回选中时高度 *int32) {
	xList_GetRowHeight.Call(uintptr(元素句柄), uintptr(行索引), uintptr(unsafe.Pointer(返回高度)), uintptr(unsafe.Pointer(返回选中时高度)))
}

// 列表_置拖动矩形颜色.
//
//
//
// ff:列表_设置拖动矩形颜色
// hEle:元素句柄
// color:ABGR颜色值
// width:线宽度
func X列表_设置拖动矩形颜色(元素句柄 int, ABGR颜色值 int, 线宽度 int32) {
	xList_SetDragRectColor.Call(uintptr(元素句柄), uintptr(ABGR颜色值), uintptr(线宽度))
}

// 列表_取项模板. 返回列表项模板句柄.
//
// ff:列表_取项模板
// hEle:元素句柄
func X列表_取项模板(元素句柄 int) int {
	r, _, _ := xList_GetItemTemplate.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_取项模板列表头. 返回列表头项模板句柄.
//
// ff:列表_取项模板列表头
// hEle:元素句柄
func X列表_取项模板列表头(元素句柄 int) int {
	r, _, _ := xList_GetItemTemplateHeader.Call(uintptr(元素句柄))
	return int(r)
}

// 列表_刷新项数据列表头.
//
// ff:列表_刷新项数据列表头
// hEle:元素句柄
func X列表_刷新项数据列表头(元素句柄 int) {
	xList_RefreshDataHeader.Call(uintptr(元素句柄))
}

// 列表_置项模板从内存.
//
//
// ff:列表_设置项模板从内存
// hEle:元素句柄
// data:模板数据
func X列表_设置项模板从内存(元素句柄 int, 模板数据 []byte) bool {
	r, _, _ := xList_SetItemTemplateXMLFromMem.Call(uintptr(元素句柄), common.X字节集到uintptr(&模板数据), uintptr(int32(len(模板数据))))
	return r != 0
}

// 列表_置项模板从资源ZIP. 从RC资源ZIP加载.
//
//
//
//
//
// ff:列表_设置项模板从资源zip
// hEle:元素句柄
// id:RC资源ID
// pFileName:项模板文件名
// pPassword:zip密码
// hModule:模块句柄
func X列表_设置项模板从资源zip(元素句柄 int, RC资源ID int32, 项模板文件名 string, zip密码 string, 模块句柄 uintptr) bool {
	r, _, _ := xList_SetItemTemplateXMLFromZipRes.Call(uintptr(元素句柄), uintptr(RC资源ID), common.X文本到uintptr(项模板文件名), common.X文本到uintptr(zip密码), 模块句柄)
	return r != 0
}

// 列表_添加列文本2, 返回列索引. 简化版本.
//
//
//
// ff:列表_添加列文本2
// hEle:元素句柄
// nWidth:列宽度
// pText:文本
func X列表_添加列文本2(元素句柄 int, 列宽度 int32, 文本 string) int32 {
	r, _, _ := xList_AddColumnText2.Call(uintptr(元素句柄), uintptr(列宽度), common.X文本到uintptr(文本))
	return int32(r)
}

// 列表_添加列图片2, 返回列索引. 简化版本.
//
//
//
// ff:列表_添加列图片2
// hEle:元素句柄
// nWidth:列宽度
// hImage:图片句柄
func X列表_添加列图片2(元素句柄 int, 列宽度 int32, 图片句柄 int) int32 {
	r, _, _ := xList_AddColumnImage2.Call(uintptr(元素句柄), uintptr(列宽度), uintptr(图片句柄))
	return int32(r)
}

// 列表_创建数据适配器2. 创建数据适配器，根据绑定的项模板初始化数据适配器的列(字段名); 数据适配器存储数据, UI对象根据绑定的字段名显示数据适配器中对应的数据; 此接口是简化接口, 合并了 xc.XList_CreateAdapter() 和 xc.XList_CreateAdapterHeader() 接口;
//
//
// ff:列表_创建数据适配器2
// hEle:元素句柄
// col_extend_count:预计列表总列数
func X列表_创建数据适配器2(元素句柄 int, 预计列表总列数 int32) bool {
	r, _, _ := xList_CreateAdapters.Call(uintptr(元素句柄), uintptr(预计列表总列数))
	return r != 0
}
